Termination w.r.t. Q proof of TRS/secret05cime3.trs

Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.

↳ QTRS

  ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.

Using Dependency Pairs [1,13] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
MARK₁(d) -> A__D
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X2)
A__B -> A__D
MARK₁(c) -> A__C
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X1)
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
MARK₁(a) -> A__A
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X3)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(h₂(X1, X2)) -> A__H₂(mark₁(X1), mark₁(X2))
A__A -> A__D
A__A¹ -> A__B
MARK₁(b) -> A__B
A__A -> A__C
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)
A__A¹ -> A__F₁(a__a)
A__B -> A__C
MARK₁(A) -> A__A¹
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(k) -> A__K
A__A¹ -> A__A
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> MARK₁(X1)
A__H₂(X, X) -> A__K
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
MARK₁(g₃(X1, X2, X3)) -> A__G₃(mark₁(X1), mark₁(X2), mark₁(X3))
MARK₁(h₂(X1, X2)) -> MARK₁(X2)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
MARK₁(d) -> A__D
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X2)
A__B -> A__D
MARK₁(c) -> A__C
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X1)
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
MARK₁(a) -> A__A
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X3)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(h₂(X1, X2)) -> A__H₂(mark₁(X1), mark₁(X2))
A__A -> A__D
A__A¹ -> A__B
MARK₁(b) -> A__B
A__A -> A__C
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)
A__A¹ -> A__F₁(a__a)
A__B -> A__C
MARK₁(A) -> A__A¹
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(k) -> A__K
A__A¹ -> A__A
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> MARK₁(X1)
A__H₂(X, X) -> A__K
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
MARK₁(g₃(X1, X2, X3)) -> A__G₃(mark₁(X1), mark₁(X2), mark₁(X3))
MARK₁(h₂(X1, X2)) -> MARK₁(X2)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 1 SCC with 12 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
A__A¹ -> A__F₁(a__a)
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X2)
MARK₁(A) -> A__A¹
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X1)
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
A__F₁(X) -> MARK₁(X)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X3)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> A__H₂(mark₁(X1), mark₁(X2))
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
MARK₁(g₃(X1, X2, X3)) -> A__G₃(mark₁(X1), mark₁(X2), mark₁(X3))
MARK₁(h₂(X1, X2)) -> MARK₁(X2)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MARK₁(g₃(X1, X2, X3)) -> MARK₁(X2)
MARK₁(A) -> A__A¹
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X1)
MARK₁(g₃(X1, X2, X3)) -> MARK₁(X3)
MARK₁(h₂(X1, X2)) -> MARK₁(X1)
MARK₁(h₂(X1, X2)) -> A__H₂(mark₁(X1), mark₁(X2))
MARK₁(g₃(X1, X2, X3)) -> A__G₃(mark₁(X1), mark₁(X2), mark₁(X3))
MARK₁(h₂(X1, X2)) -> MARK₁(X2)

The remaining pairs can at least be oriented weakly.

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
A__A¹ -> A__F₁(a__a)
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
A__F₁(X) -> MARK₁(X)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( A__A¹ ) = 2

POL( k ) = 0

POL( a ) = max{0, -1}

POL( a__f₁(x₁) ) = 2x₁

POL( a__k ) = max{0, -2}

POL( a__z₂(x₁, x₂) ) = x₁ + x₂

POL( d ) = 0

POL( A__H₂(x₁, x₂) ) = 2x₁ + 2

POL( a__g₃(x₁, ..., x₃) ) = 2x₁ + x₂ + x₃ + 1

POL( A ) = 1

POL( c ) = max{0, -1}

POL( l ) = 0

POL( A__F₁(x₁) ) = x₁ + 2

POL( a__A ) = 1

POL( h₂(x₁, x₂) ) = 2x₁ + 2x₂ + 1

POL( a__d ) = max{0, -2}

POL( b ) = max{0, -1}

POL( mark₁(x₁) ) = x₁

POL( g₃(x₁, ..., x₃) ) = 2x₁ + x₂ + x₃ + 1

POL( m ) = max{0, -1}

POL( f₁(x₁) ) = 2x₁

POL( MARK₁(x₁) ) = x₁ + 2

POL( a__a ) = 0

POL( e ) = max{0, -2}

POL( A__G₃(x₁, ..., x₃) ) = 2

POL( z₂(x₁, x₂) ) = x₁ + x₂

POL( a__c ) = max{0, -2}

POL( A__Z₂(x₁, x₂) ) = x₂ + 2

POL( a__h₂(x₁, x₂) ) = 2x₁ + 2x₂ + 1

POL( a__b ) = max{0, -2}

The following usable rules [14] were oriented:

a__b -> b
a__z₂(X1, X2) -> z₂(X1, X2)
a__b -> a__c
a__d -> d
a__c -> e
mark₁(k) -> a__k
mark₁(e) -> e
a__c -> c
a__a -> a__c
a__k -> l
a__k -> k
a__b -> a__d
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(A) -> a__A
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(c) -> a__c
a__a -> a__d
mark₁(l) -> l
mark₁(a) -> a__a
a__k -> m
a__f₁(X) -> f₁(X)
mark₁(b) -> a__b
a__c -> l
a__a -> a
a__h₂(X1, X2) -> h₂(X1, X2)
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__g₃(d, X, X) -> a__A
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
a__A -> A
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)
a__d -> m
mark₁(m) -> m
mark₁(d) -> a__d

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
A__A¹ -> A__F₁(a__a)
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
A__F₁(X) -> MARK₁(X)
A__A¹ -> A__F₁(a__b)
A__H₂(X, X) -> A__F₁(a__k)
A__H₂(X, X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
A__G₃(d, X, X) -> A__A¹
A__Z₂(e, X) -> MARK₁(X)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 2 SCCs with 4 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                    ↳ QDPOrderProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

A__Z₂(e, X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
A__F₁(X) -> MARK₁(X)
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
A__F₁(X) -> A__Z₂(mark₁(X), X)
MARK₁(f₁(X)) -> MARK₁(X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
We use the reduction pair processor [13].

The following pairs can be oriented strictly and are deleted.

MARK₁(z₂(X1, X2)) -> A__Z₂(mark₁(X1), X2)
MARK₁(f₁(X)) -> A__F₁(mark₁(X))
MARK₁(z₂(X1, X2)) -> MARK₁(X1)
MARK₁(f₁(X)) -> MARK₁(X)

The remaining pairs can at least be oriented weakly.

A__Z₂(e, X) -> MARK₁(X)
A__F₁(X) -> MARK₁(X)
A__F₁(X) -> A__Z₂(mark₁(X), X)

Used ordering: Polynomial Order [17,21] with Interpretation:

POL( k ) = 1

POL( a ) = 2

POL( a__f₁(x₁) ) = 2x₁ + 2

POL( a__k ) = 1

POL( a__z₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( d ) = max{0, -2}

POL( a__g₃(x₁, ..., x₃) ) = max{0, -1}

POL( A ) = 0

POL( c ) = 2

POL( l ) = max{0, -2}

POL( A__F₁(x₁) ) = 2x₁ + 2

POL( a__A ) = max{0, -2}

POL( h₂(x₁, x₂) ) = max{0, -1}

POL( a__d ) = max{0, -1}

POL( b ) = 2

POL( mark₁(x₁) ) = x₁

POL( g₃(x₁, ..., x₃) ) = 0

POL( m ) = max{0, -1}

POL( f₁(x₁) ) = 2x₁ + 2

POL( MARK₁(x₁) ) = 2x₁ + 2

POL( a__a ) = 2

POL( e ) = 0

POL( z₂(x₁, x₂) ) = x₁ + x₂ + 1

POL( a__c ) = 2

POL( A__Z₂(x₁, x₂) ) = 2x₂ + 2

POL( a__h₂(x₁, x₂) ) = max{0, -2}

POL( a__b ) = 2

The following usable rules [14] were oriented:

a__b -> b
a__z₂(X1, X2) -> z₂(X1, X2)
a__b -> a__c
a__d -> d
a__c -> e
mark₁(k) -> a__k
mark₁(e) -> e
a__c -> c
a__a -> a__c
a__k -> l
a__k -> k
a__b -> a__d
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(A) -> a__A
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(c) -> a__c
a__a -> a__d
mark₁(l) -> l
mark₁(a) -> a__a
a__k -> m
a__f₁(X) -> f₁(X)
mark₁(b) -> a__b
a__c -> l
a__a -> a
a__h₂(X1, X2) -> h₂(X1, X2)
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__g₃(d, X, X) -> a__A
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
a__A -> A
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)
a__d -> m
mark₁(m) -> m
mark₁(d) -> a__d

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                    ↳ QDPOrderProof

                      ↳ QDP

                        ↳ DependencyGraphProof

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

A__Z₂(e, X) -> MARK₁(X)
A__F₁(X) -> MARK₁(X)
A__F₁(X) -> A__Z₂(mark₁(X), X)

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [13,14,18] contains 0 SCCs with 3 less nodes.

↳ QTRS

  ↳ DependencyPairsProof

    ↳ QDP

      ↳ DependencyGraphProof

        ↳ QDP

          ↳ QDPOrderProof

            ↳ QDP

              ↳ DependencyGraphProof

                ↳ AND

                  ↳ QDP

                  ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

A__H₂(X, X) -> A__G₃(mark₁(X), mark₁(X), a__f₁(a__k))
A__A¹ -> A__H₂(a__f₁(a__a), a__f₁(a__b))
A__G₃(d, X, X) -> A__A¹

The TRS R consists of the following rules:

a__a -> a__c
a__b -> a__c
a__c -> e
a__k -> l
a__d -> m
a__a -> a__d
a__b -> a__d
a__c -> l
a__k -> m
a__A -> a__h₂(a__f₁(a__a), a__f₁(a__b))
a__h₂(X, X) -> a__g₃(mark₁(X), mark₁(X), a__f₁(a__k))
a__g₃(d, X, X) -> a__A
a__f₁(X) -> a__z₂(mark₁(X), X)
a__z₂(e, X) -> mark₁(X)
mark₁(A) -> a__A
mark₁(a) -> a__a
mark₁(b) -> a__b
mark₁(c) -> a__c
mark₁(d) -> a__d
mark₁(k) -> a__k
mark₁(z₂(X1, X2)) -> a__z₂(mark₁(X1), X2)
mark₁(f₁(X)) -> a__f₁(mark₁(X))
mark₁(h₂(X1, X2)) -> a__h₂(mark₁(X1), mark₁(X2))
mark₁(g₃(X1, X2, X3)) -> a__g₃(mark₁(X1), mark₁(X2), mark₁(X3))
mark₁(e) -> e
mark₁(l) -> l
mark₁(m) -> m
a__A -> A
a__a -> a
a__b -> b
a__c -> c
a__d -> d
a__k -> k
a__z₂(X1, X2) -> z₂(X1, X2)
a__f₁(X) -> f₁(X)
a__h₂(X1, X2) -> h₂(X1, X2)
a__g₃(X1, X2, X3) -> g₃(X1, X2, X3)

Q is empty.
We have to consider all minimal (P,Q,R)-chains.